/**
 * @file 设备管理组合式函数
 * @description 封装设备选择、搜索、过滤等设备管理相关逻辑
 * @date 2024-06-24
 */

// @ts-ignore
import { ref, computed, onMounted, onUnmounted, watch } from 'vue';
import { useDeviceStore } from '@/stores/modules/device';
import { useWindowSize } from '@/hooks/common/useWindowSize';
import { debounce } from '@/utils/helpers/common';
import type { DeviceInfo } from '@/api/track';

// 扩展DeviceInfo类型，确保包含name属性
export interface ExtendedDeviceInfo extends DeviceInfo {
  name?: string;
}

/**
 * 设备管理选项
 */
export interface DeviceManagementOptions {
  /** 是否自动加载设备列表 */
  autoLoad?: boolean;
  /** 自动刷新间隔，单位毫秒，设为0或负数则禁用自动刷新 */
  refreshInterval?: number;
  /** 清除轨迹的回调函数 */
  onClearTrack?: (reason?: string, force?: boolean) => void;
  /** 获取轨迹数据的回调函数 */
  onFetchTrack?: () => Promise<void>;
}

/**
 * 设备管理组合式函数
 * @param options 设备管理选项
 * @returns 设备管理相关状态和方法
 */
export function useDeviceManagement(options: DeviceManagementOptions = {}) {
  // 合并默认选项
  const mergedOptions = {
    autoLoad: options.autoLoad !== undefined ? options.autoLoad : true,
    refreshInterval: options.refreshInterval !== undefined ? options.refreshInterval : 5000,
    onClearTrack: options.onClearTrack || (() => {}),
    onFetchTrack: options.onFetchTrack || (() => Promise.resolve())
  };
  
  // 设备状态管理
  const deviceStore = useDeviceStore();
  
  // 设备相关状态
  const selectedDeviceId = ref('');
  const deviceName = ref('');
  const allDevices = ref<ExtendedDeviceInfo[]>([]);
  const searchKeyword = ref('');
  const showDeviceList = ref(true);
  const activeTab = ref('realtime');
  const isMobileView = ref(false);
  
  // 计算属性
  const deviceOptions = computed(() => {
    return deviceStore.deviceList.map((device: ExtendedDeviceInfo) => device.deviceId);
  });
  
  // 刷新定时器
  let refreshInterval: number | null = null;
  
  /**
   * 加载设备列表
   */
  const loadDeviceList = async (): Promise<void> => {
    try {
      await deviceStore.fetchDeviceList();
      console.log('设备列表加载成功，设备数量:', deviceStore.deviceList.length);
      allDevices.value = [...deviceStore.deviceList];
    } catch (error) {
      console.error('加载设备列表失败:', error);
    }
  };
  
  /**
   * 刷新设备列表
   */
  const refreshDeviceList = async (): Promise<void> => {
    try {
      await deviceStore.refreshDeviceList();
      
      // 实时模式下也更新一下完整设备列表
      if (deviceStore.deviceList.length > allDevices.value.length) {
        allDevices.value = [...deviceStore.deviceList];
      }
    } catch (error) {
      console.error('刷新设备列表失败:', error);
    }
  };
  
  /**
   * 设置自动刷新间隔
   * @param interval 刷新间隔(ms)，设为0则停止自动刷新
   */
  const setRefreshInterval = (interval: number): void => {
    // 清除现有定时器
    if (refreshInterval !== null) {
      clearInterval(refreshInterval);
      refreshInterval = null;
    }
    
    // 设置新的定时器（如果间隔大于0）
    if (interval > 0) {
      refreshInterval = setInterval(() => {
        if (activeTab.value === 'realtime') {
          refreshDeviceList();
        }
      }, interval) as unknown as number;
    }
  };
  
  /**
   * 处理设备选择
   * @param device 选中的设备信息
   */
  const handleSelectDevice = (device: ExtendedDeviceInfo): void => {
    console.log('选择设备:', device.deviceId, device.name);
    
    const isNewDevice = selectedDeviceId.value !== device.deviceId;
    const isSameDevice = selectedDeviceId.value === device.deviceId;
    
    // 如果选择了不同的设备，清除当前轨迹
    if (isNewDevice) {
      mergedOptions.onClearTrack('切换到新设备');
    }
    // 如果重复点击相同设备，也清除轨迹
    else if (isSameDevice) {
      mergedOptions.onClearTrack('重复点击相同设备');
    }
    
    selectedDeviceId.value = device.deviceId;
    deviceName.value = device.name || device.deviceId;
    
    // 如果当前是轨迹查询模式，则查询轨迹
    if (activeTab.value === 'history') {
      if (isNewDevice || isSameDevice) {
        debouncedFetchTrackData();
      }
    }
  };
  
  /**
   * 处理设备变更（移动端设备选择器）
   * @param deviceId 设备ID
   */
  const handleDeviceChange = (deviceId: string): void => {
    const isNewDevice = selectedDeviceId.value !== deviceId;
    const isSameDevice = selectedDeviceId.value === deviceId;
    
    // 如果选择了不同的设备，清除当前轨迹
    if (isNewDevice) {
      mergedOptions.onClearTrack('设备变更');
    }
    // 如果重复选择相同设备，也清除轨迹
    else if (isSameDevice) {
      mergedOptions.onClearTrack('重复选择相同设备');
    }
    
    selectedDeviceId.value = deviceId;
    
    // 获取设备名称
    const device = deviceStore.deviceList.find((d: ExtendedDeviceInfo) => d.deviceId === deviceId);
    if (device) {
      deviceName.value = device.name || device.deviceId;
    }
    
    // 如果当前是轨迹查询模式，则查询轨迹
    if (activeTab.value === 'history') {
      if (isNewDevice || isSameDevice) {
        debouncedFetchTrackData();
      }
    }
  };
  
  /**
   * 处理状态过滤
   * @param status 设备状态
   */
  const handleStatusFilter = (status: number): void => {
    // 这里仅处理轨迹模式下，当设备因状态过滤被移除的情况
    if (activeTab.value === 'history' && selectedDeviceId.value) {
      // 延迟执行，确保设备列表已经根据状态过滤完成
      setTimeout(() => {
        // 检查当前选中的设备在过滤后的列表中是否存在
        const deviceExists = deviceStore.deviceList.some((d: ExtendedDeviceInfo) => d.deviceId === selectedDeviceId.value);
        
        if (!deviceExists) {
          // 如果设备不在当前过滤列表中，尝试找到一个可见的设备来替代
          if (deviceStore.deviceList.length > 0) {
            selectedDeviceId.value = deviceStore.deviceList[0].deviceId;
            
            // 获取设备名称
            const device = deviceStore.deviceList[0];
            deviceName.value = device.name || device.deviceId;
          }
        }
        
        // 如有选中设备，查询轨迹
        if (selectedDeviceId.value) {
          mergedOptions.onFetchTrack();
        }
      }, 100);
    }
  };
  
  /**
   * 处理搜索
   * @param keyword 搜索关键词
   */
  const handleSearch = (keyword: string): void => {
    searchKeyword.value = keyword;
    // 搜索逻辑已在GPSManagePanel组件内处理
  };
  
  /**
   * 处理标签页切换
   * @param tab 标签页名称
   */
  const handleTabChange = (tab: string): void => {
    activeTab.value = tab;
  };
  
  /**
   * 处理设备ID URL参数
   * @param deviceId 设备ID
   */
  const handleDeviceIdParam = async (deviceId: string): Promise<void> => {
    console.log('从页面参数中获取设备ID:', deviceId);
    
    try {
      // 确保设备列表已加载
      if (deviceStore.deviceList.length === 0) {
        await deviceStore.fetchDeviceList();
      }
      
      // 查找设备信息
      const targetDevice = deviceStore.deviceList.find((device: ExtendedDeviceInfo) => device.deviceId === deviceId);
      
      if (targetDevice) {
        console.log('找到对应设备:', targetDevice.name || targetDevice.deviceId);
        selectedDeviceId.value = deviceId;
        deviceName.value = targetDevice.name || targetDevice.deviceId;
      } else {
        console.log('未找到设备ID对应的设备信息:', deviceId);
      }
    } catch (error) {
      console.error('处理页面参数时出错:', error);
    }
  };
  
  // 使用防抖包装轨迹查询函数
  const debouncedFetchTrackData = debounce(() => {
    return mergedOptions.onFetchTrack();
  }, 300);
  
  // 返回一个解包过的对象，便于在模板中直接使用
  const unwrapped = computed(() => ({
    selectedDeviceId: selectedDeviceId.value,
    deviceName: deviceName.value,
    allDevices: allDevices.value,
    searchKeyword: searchKeyword.value,
    showDeviceList: showDeviceList.value,
    activeTab: activeTab.value,
    isMobileView: isMobileView.value,
    deviceOptions: deviceOptions.value
  }));
  
  // 初始化设备管理
  onMounted(async () => {
    // 获取窗口尺寸信息
    const { width } = useWindowSize();
    isMobileView.value = width.value < 768;
    
    // 自动加载设备列表
    if (mergedOptions.autoLoad) {
      await loadDeviceList();
    }
    
    // 设置自动刷新
    if (mergedOptions.refreshInterval > 0) {
      setRefreshInterval(mergedOptions.refreshInterval);
    }
  });
  
  // 监听窗口大小变化
  const { width } = useWindowSize();
  watch(width, (newWidth: number) => {
    isMobileView.value = newWidth < 768;
  });
  
  // 清理资源
  onUnmounted(() => {
    // 清除刷新定时器
    if (refreshInterval !== null) {
      clearInterval(refreshInterval);
      refreshInterval = null;
    }
  });
  
  return {
    // 状态
    selectedDeviceId,
    deviceName,
    allDevices,
    searchKeyword,
    showDeviceList,
    activeTab,
    isMobileView,
    deviceOptions,
    
    // 解包后的状态对象，便于在模板中使用
    unwrapped,
    
    // 方法
    loadDeviceList,
    refreshDeviceList,
    setRefreshInterval,
    handleSelectDevice,
    handleDeviceChange,
    handleStatusFilter,
    handleSearch,
    handleTabChange,
    handleDeviceIdParam,
    debouncedFetchTrackData
  };
} 